/*
		 * https://underscorejs.org/  JS类库（提供很多项目中需要经常使用的方法）
		 *
		 * 函数的防抖（debounce）：不是某个事件触发就去执行函数，而是在指定的时间间隔内，执行一次，减少函数执行的次数
		 *
		 * 函数的节流（throttle）：为了缩减执行的频率，但不像防抖一样，一定时间内只能执行一次，而是一定时间内能执行多次
		 */

/*
 * debounce:函数防抖
 *   @params
 *      func:要执行的函数
 *      wait:间隔等待时间
 *      immediate:在开始边界还是结束边界触发执行(TRUE=>在开始边界)
 *   @return
 *      可被调用的函数
 */
function debounce(func, wait, immediate) {
    let result = null,
        timeout = null;
    return function (...args) {
        let context = this,
            now = immediate && !timeout;
        clearTimeout(timeout); //=>重要：在设置新的定时器之前，我们要把之前设置的定时器都干掉，因为防抖的目的是等待时间内，只执行一次
        timeout = setTimeout(() => {
            timeout = null;
            if (!immediate) result = func.call(context, ...args);
        }, wait);
        if (now) result = func.call(context, ...args);
        return result;
    }
}

/*
 * throttle：函数节流是为了缩减执行频率，当达到了一定的时间间隔就会执行一次
 */
function throttle(func,delay){
    var result=null,
        pre=Data.now()
    return function (...arg){
        var now=Data.now()
        if(now-pre>=delay){
            pre=Data.now()
            result=func.call(this,...arg)
        }
        return result
    }
}

function debounce(fn,delay){
    var result=null
    var timeout=null
    return function (...args){
        clearTimeout(timeout)
        timeout=setTimeout(()=>{
            timeout=null
            result=fn.call(this,...args)
        },delay)
        return result
    }
}

function throtter(fn,delay){
    var result=null
    var pre=Date.now()
    return function (...args){
        var now=Date.now()
        if(now-pre>=delay){
            pre=Date.now()
            result=fn.call(this,...args)
        }
        return result
    }
}
